diff --git a/cryptography/bindings/__init__.py b/cryptography/bindings/__init__.py
index 215f17c..5006d13 100644
--- a/cryptography/bindings/__init__.py
+++ b/cryptography/bindings/__init__.py
@@ -14,7 +14,7 @@
 from cryptography.bindings import openssl
 
 
-_default_api = openssl.api
-_ALL_APIS = [
-    openssl.api
+_default_backend = openssl.backend
+_ALL_BACKENDS = [
+    openssl.backend
 ]
diff --git a/cryptography/bindings/openssl/__init__.py b/cryptography/bindings/openssl/__init__.py
index 103b1db..cfe2e66 100644
--- a/cryptography/bindings/openssl/__init__.py
+++ b/cryptography/bindings/openssl/__init__.py
@@ -11,7 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from cryptography.bindings.openssl.api import api
+from cryptography.bindings.openssl.backend import backend
 
 
-__all__ = ["api"]
+__all__ = ["backend"]
diff --git a/cryptography/bindings/openssl/api.py b/cryptography/bindings/openssl/backend.py
similarity index 96%
rename from cryptography/bindings/openssl/api.py
rename to cryptography/bindings/openssl/backend.py
index fedaf9c..492f2e5 100644
--- a/cryptography/bindings/openssl/api.py
+++ b/cryptography/bindings/openssl/backend.py
@@ -27,12 +27,12 @@
     def __init__(self, fmt):
         self._fmt = fmt
 
-    def __call__(self, api, cipher, mode):
+    def __call__(self, backend, cipher, mode):
         cipher_name = self._fmt.format(cipher=cipher, mode=mode).lower()
-        return api.lib.EVP_get_cipherbyname(cipher_name.encode("ascii"))
+        return backend.lib.EVP_get_cipherbyname(cipher_name.encode("ascii"))
 
 
-class API(object):
+class Backend(object):
     """
     OpenSSL API wrapper.
     """
@@ -144,7 +144,7 @@
 
     def create_block_cipher_encrypt_context(self, cipher, mode):
         ctx, evp, iv_nonce = self._create_block_cipher_context(cipher, mode)
-        res = self.lib.EVP_EncryptInit_ex(ctx, evp, api.ffi.NULL, cipher.key,
+        res = self.lib.EVP_EncryptInit_ex(ctx, evp, self.ffi.NULL, cipher.key,
                                           iv_nonce)
         assert res != 0
         # We purposely disable padding here as it's handled higher up in the
@@ -154,7 +154,7 @@
 
     def create_block_cipher_decrypt_context(self, cipher, mode):
         ctx, evp, iv_nonce = self._create_block_cipher_context(cipher, mode)
-        res = self.lib.EVP_DecryptInit_ex(ctx, evp, api.ffi.NULL, cipher.key,
+        res = self.lib.EVP_DecryptInit_ex(ctx, evp, self.ffi.NULL, cipher.key,
                                           iv_nonce)
         assert res != 0
         # We purposely disable padding here as it's handled higher up in the
@@ -247,4 +247,4 @@
         return copied_ctx
 
 
-api = API()
+backend = Backend()
diff --git a/cryptography/primitives/block/base.py b/cryptography/primitives/block/base.py
index 12b6f62..e9f5288 100644
--- a/cryptography/primitives/block/base.py
+++ b/cryptography/primitives/block/base.py
@@ -17,58 +17,62 @@
 
 
 class BlockCipher(object):
-    def __init__(self, cipher, mode, api=None):
+    def __init__(self, cipher, mode, backend=None):
         super(BlockCipher, self).__init__()
 
-        if api is None:
-            from cryptography.bindings import _default_api as api
+        if backend is None:
+            from cryptography.bindings import _default_backend as backend
 
         self.cipher = cipher
         self.mode = mode
-        self._api = api
+        self._backend = backend
 
     def encryptor(self):
-        return _CipherEncryptionContext(self.cipher, self.mode, self._api)
+        return _CipherEncryptionContext(self.cipher, self.mode, self._backend)
 
     def decryptor(self):
-        return _CipherDecryptionContext(self.cipher, self.mode, self._api)
+        return _CipherDecryptionContext(self.cipher, self.mode, self._backend)
 
 
 @interfaces.register(interfaces.CipherContext)
 class _CipherEncryptionContext(object):
-    def __init__(self, cipher, mode, api):
+    def __init__(self, cipher, mode, backend):
         super(_CipherEncryptionContext, self).__init__()
-        self._api = api
-        self._ctx = self._api.create_block_cipher_encrypt_context(cipher, mode)
+        self._backend = backend
+        self._ctx = self._backend.create_block_cipher_encrypt_context(
+            cipher, mode
+        )
 
     def update(self, data):
         if self._ctx is None:
             raise ValueError("Context was already finalized")
-        return self._api.update_encrypt_context(self._ctx, data)
+        return self._backend.update_encrypt_context(self._ctx, data)
 
     def finalize(self):
         if self._ctx is None:
             raise ValueError("Context was already finalized")
-        data = self._api.finalize_encrypt_context(self._ctx)
+        data = self._backend.finalize_encrypt_context(self._ctx)
         self._ctx = None
         return data
 
 
 @interfaces.register(interfaces.CipherContext)
 class _CipherDecryptionContext(object):
-    def __init__(self, cipher, mode, api):
+    def __init__(self, cipher, mode, backend):
         super(_CipherDecryptionContext, self).__init__()
-        self._api = api
-        self._ctx = self._api.create_block_cipher_decrypt_context(cipher, mode)
+        self._backend = backend
+        self._ctx = self._backend.create_block_cipher_decrypt_context(
+            cipher, mode
+        )
 
     def update(self, data):
         if self._ctx is None:
             raise ValueError("Context was already finalized")
-        return self._api.update_decrypt_context(self._ctx, data)
+        return self._backend.update_decrypt_context(self._ctx, data)
 
     def finalize(self):
         if self._ctx is None:
             raise ValueError("Context was already finalized")
-        data = self._api.finalize_decrypt_context(self._ctx)
+        data = self._backend.finalize_decrypt_context(self._ctx)
         self._ctx = None
         return data
diff --git a/cryptography/primitives/hashes.py b/cryptography/primitives/hashes.py
index 7133a91..f3eccc6 100644
--- a/cryptography/primitives/hashes.py
+++ b/cryptography/primitives/hashes.py
@@ -19,35 +19,38 @@
 
 import six
 
-from cryptography.bindings import _default_api
-
 
 class BaseHash(six.with_metaclass(abc.ABCMeta)):
-    def __init__(self, data=None, api=None, ctx=None):
-        if api is None:
-            api = _default_api
-        self._api = api
-        self._ctx = self._api.create_hash_context(self) if ctx is None else ctx
+    def __init__(self, data=None, backend=None, ctx=None):
+        if backend is None:
+            from cryptography.bindings import _default_backend
+            backend = _default_backend
+        self._backend = backend
+        if ctx is None:
+            self._ctx = self._backend.create_hash_context(self)
+        else:
+            self._ctx = None
+
         if data is not None:
             self.update(data)
 
     def update(self, data):
         if isinstance(data, six.text_type):
             raise TypeError("Unicode-objects must be encoded before hashing")
-        self._api.update_hash_context(self._ctx, data)
+        self._backend.update_hash_context(self._ctx, data)
 
     def copy(self):
         return self.__class__(ctx=self._copy_ctx())
 
     def digest(self):
-        return self._api.finalize_hash_context(self._copy_ctx(),
-                                               self.digest_size)
+        return self._backend.finalize_hash_context(self._copy_ctx(),
+                                                   self.digest_size)
 
     def hexdigest(self):
         return str(binascii.hexlify(self.digest()).decode("ascii"))
 
     def _copy_ctx(self):
-        return self._api.copy_hash_context(self._ctx)
+        return self._backend.copy_hash_context(self._ctx)
 
 
 class SHA1(BaseHash):
diff --git a/docs/bindings/openssl.rst b/docs/bindings/openssl.rst
index 241cc4d..14d6211 100644
--- a/docs/bindings/openssl.rst
+++ b/docs/bindings/openssl.rst
@@ -3,16 +3,16 @@
 
 .. warning::
 
-    The OpenSSL API is not easy to use, small mistakes can lead to significant
+    The OpenSSL backend is not easy to use, small mistakes can lead to significant
     security vulnerabilities. We strongly recommend not using this directly,
     and instead using one of the higher level APIs exposed by ``cryptography``.
 
 
 These are `CFFI`_ bindings to the `OpenSSL`_ C library.
 
-.. data:: cryptography.bindings.openssl.api
+.. data:: cryptography.bindings.openssl.backend
 
-    This is the exposed API for the OpenSSL bindings. It has two public
+    This is the exposed backend for the OpenSSL bindings. It has two public
     attributes:
 
     .. attribute:: ffi
diff --git a/tests/bindings/test_openssl.py b/tests/bindings/test_openssl.py
index bf201e4..bdfbed3 100644
--- a/tests/bindings/test_openssl.py
+++ b/tests/bindings/test_openssl.py
@@ -13,14 +13,14 @@
 
 import pytest
 
-from cryptography.bindings.openssl.api import api
+from cryptography.bindings.openssl.backend import backend
 from cryptography.primitives.block.ciphers import AES
 from cryptography.primitives.block.modes import CBC
 
 
 class TestOpenSSL(object):
-    def test_api_exists(self):
-        assert api
+    def test_backend_exists(self):
+        assert backend
 
     def test_openssl_version_text(self):
         """
@@ -31,11 +31,11 @@
         if it starts with OpenSSL as that appears to be true
         for every OpenSSL.
         """
-        assert api.openssl_version_text().startswith("OpenSSL")
+        assert backend.openssl_version_text().startswith("OpenSSL")
 
     def test_supports_cipher(self):
-        assert api.supports_cipher(None, None) is False
+        assert backend.supports_cipher(None, None) is False
 
     def test_register_duplicate_cipher_adapter(self):
         with pytest.raises(ValueError):
-            api.register_cipher_adapter(AES, CBC, None)
+            backend.register_cipher_adapter(AES, CBC, None)
diff --git a/tests/conftest.py b/tests/conftest.py
index b526f2b..d2ba03d 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,5 +1,5 @@
 def pytest_generate_tests(metafunc):
-    from cryptography.bindings import _ALL_APIS
+    from cryptography.bindings import _ALL_BACKENDS
 
-    if "api" in metafunc.fixturenames:
-        metafunc.parametrize("api", _ALL_APIS)
+    if "backend" in metafunc.fixturenames:
+        metafunc.parametrize("backend", _ALL_BACKENDS)
diff --git a/tests/primitives/test_block.py b/tests/primitives/test_block.py
index 5e147a7..3b3b1f9 100644
--- a/tests/primitives/test_block.py
+++ b/tests/primitives/test_block.py
@@ -22,7 +22,7 @@
 
 
 class TestBlockCipher(object):
-    def test_instantiate_without_api(self):
+    def test_instantiate_without_backend(self):
         BlockCipher(
             ciphers.AES(binascii.unhexlify(b"0" * 32)),
             modes.CBC(binascii.unhexlify(b"0" * 32))
@@ -44,11 +44,11 @@
 
 
 class TestBlockCipherContext(object):
-    def test_use_after_finalize(self, api):
+    def test_use_after_finalize(self, backend):
         cipher = BlockCipher(
             ciphers.AES(binascii.unhexlify(b"0" * 32)),
             modes.CBC(binascii.unhexlify(b"0" * 32)),
-            api
+            backend
         )
         encryptor = cipher.encryptor()
         encryptor.update(b"a" * 16)
@@ -65,11 +65,11 @@
         with pytest.raises(ValueError):
             decryptor.finalize()
 
-    def test_unaligned_block_encryption(self, api):
+    def test_unaligned_block_encryption(self, backend):
         cipher = BlockCipher(
             ciphers.AES(binascii.unhexlify(b"0" * 32)),
             modes.ECB(),
-            api
+            backend
         )
         encryptor = cipher.encryptor()
         ct = encryptor.update(b"a" * 15)
diff --git a/tests/primitives/test_cryptrec.py b/tests/primitives/test_cryptrec.py
index 02a0447..d8c9aaa 100644
--- a/tests/primitives/test_cryptrec.py
+++ b/tests/primitives/test_cryptrec.py
@@ -37,7 +37,7 @@
         ],
         lambda key: ciphers.Camellia(binascii.unhexlify((key))),
         lambda key: modes.ECB(),
-        only_if=lambda api: api.supports_cipher(
+        only_if=lambda backend: backend.supports_cipher(
             ciphers.Camellia("\x00" * 16), modes.ECB()
         ),
         skip_message="Does not support Camellia ECB",
diff --git a/tests/primitives/test_hash_vectors.py b/tests/primitives/test_hash_vectors.py
index 02ef4db..b42021c 100644
--- a/tests/primitives/test_hash_vectors.py
+++ b/tests/primitives/test_hash_vectors.py
@@ -30,7 +30,7 @@
             "SHA1ShortMsg.rsp",
         ],
         hashes.SHA1,
-        only_if=lambda api: api.supports_hash(hashes.SHA1),
+        only_if=lambda backend: backend.supports_hash(hashes.SHA1),
         skip_message="Does not support SHA1",
     )
 
@@ -44,7 +44,7 @@
             "SHA224ShortMsg.rsp",
         ],
         hashes.SHA224,
-        only_if=lambda api: api.supports_hash(hashes.SHA224),
+        only_if=lambda backend: backend.supports_hash(hashes.SHA224),
         skip_message="Does not support SHA224",
     )
 
@@ -58,7 +58,7 @@
             "SHA256ShortMsg.rsp",
         ],
         hashes.SHA256,
-        only_if=lambda api: api.supports_hash(hashes.SHA256),
+        only_if=lambda backend: backend.supports_hash(hashes.SHA256),
         skip_message="Does not support SHA256",
     )
 
@@ -72,7 +72,7 @@
             "SHA384ShortMsg.rsp",
         ],
         hashes.SHA384,
-        only_if=lambda api: api.supports_hash(hashes.SHA384),
+        only_if=lambda backend: backend.supports_hash(hashes.SHA384),
         skip_message="Does not support SHA384",
     )
 
@@ -86,7 +86,7 @@
             "SHA512ShortMsg.rsp",
         ],
         hashes.SHA512,
-        only_if=lambda api: api.supports_hash(hashes.SHA512),
+        only_if=lambda backend: backend.supports_hash(hashes.SHA512),
         skip_message="Does not support SHA512",
     )
 
@@ -99,14 +99,14 @@
             "ripevectors.txt",
         ],
         hashes.RIPEMD160,
-        only_if=lambda api: api.supports_hash(hashes.RIPEMD160),
+        only_if=lambda backend: backend.supports_hash(hashes.RIPEMD160),
         skip_message="Does not support RIPEMD160",
     )
 
     test_RIPEMD160_long_string = generate_long_string_hash_test(
         hashes.RIPEMD160,
         "52783243c1697bdbe16d37f97f68f08325dc1528",
-        only_if=lambda api: api.supports_hash(hashes.RIPEMD160),
+        only_if=lambda backend: backend.supports_hash(hashes.RIPEMD160),
         skip_message="Does not support RIPEMD160",
     )
 
@@ -119,7 +119,7 @@
             "iso-test-vectors.txt",
         ],
         hashes.Whirlpool,
-        only_if=lambda api: api.supports_hash(hashes.Whirlpool),
+        only_if=lambda backend: backend.supports_hash(hashes.Whirlpool),
         skip_message="Does not support Whirlpool",
     )
 
@@ -128,7 +128,7 @@
         ("0c99005beb57eff50a7cf005560ddf5d29057fd86b2"
          "0bfd62deca0f1ccea4af51fc15490eddc47af32bb2b"
          "66c34ff9ad8c6008ad677f77126953b226e4ed8b01"),
-        only_if=lambda api: api.supports_hash(hashes.Whirlpool),
+        only_if=lambda backend: backend.supports_hash(hashes.Whirlpool),
         skip_message="Does not support Whirlpool",
     )
 
@@ -141,6 +141,6 @@
             "rfc-1321.txt",
         ],
         hashes.MD5,
-        only_if=lambda api: api.supports_hash(hashes.MD5),
+        only_if=lambda backend: backend.supports_hash(hashes.MD5),
         skip_message="Does not support MD5",
     )
diff --git a/tests/primitives/test_hashes.py b/tests/primitives/test_hashes.py
index 03de891..505f6c8 100644
--- a/tests/primitives/test_hashes.py
+++ b/tests/primitives/test_hashes.py
@@ -23,13 +23,13 @@
 
 
 class TestBaseHash(object):
-    def test_base_hash_reject_unicode(self, api):
-        m = hashes.SHA1(api=api)
+    def test_base_hash_reject_unicode(self, backend):
+        m = hashes.SHA1(backend=backend)
         with pytest.raises(TypeError):
             m.update(six.u("\u00FC"))
 
-    def test_base_hash_hexdigest_string_type(self, api):
-        m = hashes.SHA1(api=api, data=b"")
+    def test_base_hash_hexdigest_string_type(self, backend):
+        m = hashes.SHA1(backend=backend, data=b"")
         assert isinstance(m.hexdigest(), str)
 
 
@@ -38,7 +38,7 @@
         hashes.SHA1,
         digest_size=20,
         block_size=64,
-        only_if=lambda api: api.supports_hash(hashes.SHA1),
+        only_if=lambda backend: backend.supports_hash(hashes.SHA1),
         skip_message="Does not support SHA1",
     )
 
@@ -48,7 +48,7 @@
         hashes.SHA224,
         digest_size=28,
         block_size=64,
-        only_if=lambda api: api.supports_hash(hashes.SHA224),
+        only_if=lambda backend: backend.supports_hash(hashes.SHA224),
         skip_message="Does not support SHA224",
     )
 
@@ -58,7 +58,7 @@
         hashes.SHA256,
         digest_size=32,
         block_size=64,
-        only_if=lambda api: api.supports_hash(hashes.SHA256),
+        only_if=lambda backend: backend.supports_hash(hashes.SHA256),
         skip_message="Does not support SHA256",
     )
 
@@ -68,7 +68,7 @@
         hashes.SHA384,
         digest_size=48,
         block_size=128,
-        only_if=lambda api: api.supports_hash(hashes.SHA384),
+        only_if=lambda backend: backend.supports_hash(hashes.SHA384),
         skip_message="Does not support SHA384",
     )
 
@@ -78,7 +78,7 @@
         hashes.SHA512,
         digest_size=64,
         block_size=128,
-        only_if=lambda api: api.supports_hash(hashes.SHA512),
+        only_if=lambda backend: backend.supports_hash(hashes.SHA512),
         skip_message="Does not support SHA512",
     )
 
@@ -88,7 +88,7 @@
         hashes.RIPEMD160,
         digest_size=20,
         block_size=64,
-        only_if=lambda api: api.supports_hash(hashes.RIPEMD160),
+        only_if=lambda backend: backend.supports_hash(hashes.RIPEMD160),
         skip_message="Does not support RIPEMD160",
     )
 
@@ -98,7 +98,7 @@
         hashes.Whirlpool,
         digest_size=64,
         block_size=64,
-        only_if=lambda api: api.supports_hash(hashes.Whirlpool),
+        only_if=lambda backend: backend.supports_hash(hashes.Whirlpool),
         skip_message="Does not support Whirlpool",
     )
 
@@ -108,6 +108,6 @@
         hashes.MD5,
         digest_size=16,
         block_size=64,
-        only_if=lambda api: api.supports_hash(hashes.MD5),
+        only_if=lambda backend: backend.supports_hash(hashes.MD5),
         skip_message="Does not support MD5",
     )
diff --git a/tests/primitives/test_openssl_vectors.py b/tests/primitives/test_openssl_vectors.py
index 86ff7ca..ff42b16 100644
--- a/tests/primitives/test_openssl_vectors.py
+++ b/tests/primitives/test_openssl_vectors.py
@@ -32,7 +32,7 @@
         ["camellia-cbc.txt"],
         lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)),
         lambda key, iv: modes.CBC(binascii.unhexlify(iv)),
-        only_if=lambda api: api.supports_cipher(
+        only_if=lambda backend: backend.supports_cipher(
             ciphers.Camellia("\x00" * 16), modes.CBC("\x00" * 16)
         ),
         skip_message="Does not support Camellia CBC",
@@ -46,7 +46,7 @@
         ["camellia-ofb.txt"],
         lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)),
         lambda key, iv: modes.OFB(binascii.unhexlify(iv)),
-        only_if=lambda api: api.supports_cipher(
+        only_if=lambda backend: backend.supports_cipher(
             ciphers.Camellia("\x00" * 16), modes.OFB("\x00" * 16)
         ),
         skip_message="Does not support Camellia OFB",
@@ -60,7 +60,7 @@
         ["camellia-cfb.txt"],
         lambda key, iv: ciphers.Camellia(binascii.unhexlify(key)),
         lambda key, iv: modes.CFB(binascii.unhexlify(iv)),
-        only_if=lambda api: api.supports_cipher(
+        only_if=lambda backend: backend.supports_cipher(
             ciphers.Camellia("\x00" * 16), modes.CFB("\x00" * 16)
         ),
         skip_message="Does not support Camellia CFB",
@@ -74,7 +74,7 @@
         ["aes-128-ctr.txt", "aes-192-ctr.txt", "aes-256-ctr.txt"],
         lambda key, iv: ciphers.AES(binascii.unhexlify(key)),
         lambda key, iv: modes.CTR(binascii.unhexlify(iv)),
-        only_if=lambda api: api.supports_cipher(
+        only_if=lambda backend: backend.supports_cipher(
             ciphers.AES("\x00" * 16), modes.CTR("\x00" * 16)
         ),
         skip_message="Does not support AES CTR",
diff --git a/tests/primitives/test_utils.py b/tests/primitives/test_utils.py
index 6e19792..b7fa3d3 100644
--- a/tests/primitives/test_utils.py
+++ b/tests/primitives/test_utils.py
@@ -10,7 +10,7 @@
         with pytest.raises(pytest.skip.Exception) as exc_info:
             encrypt_test(
                 None, None, None, None,
-                only_if=lambda api: False,
+                only_if=lambda backend: False,
                 skip_message="message!"
             )
         assert exc_info.value.args[0] == "message!"
@@ -21,7 +21,7 @@
         with pytest.raises(pytest.skip.Exception) as exc_info:
             hash_test(
                 None, None, None,
-                only_if=lambda api: False,
+                only_if=lambda backend: False,
                 skip_message="message!"
             )
         assert exc_info.value.args[0] == "message!"
@@ -32,7 +32,7 @@
         with pytest.raises(pytest.skip.Exception) as exc_info:
             base_hash_test(
                 None, None, None, None,
-                only_if=lambda api: False,
+                only_if=lambda backend: False,
                 skip_message="message!"
             )
         assert exc_info.value.args[0] == "message!"
@@ -43,7 +43,7 @@
         with pytest.raises(pytest.skip.Exception) as exc_info:
             long_string_hash_test(
                 None, None, None,
-                only_if=lambda api: False,
+                only_if=lambda backend: False,
                 skip_message="message!"
             )
         assert exc_info.value.args[0] == "message!"
diff --git a/tests/primitives/utils.py b/tests/primitives/utils.py
index 91ca36d..d3b2134 100644
--- a/tests/primitives/utils.py
+++ b/tests/primitives/utils.py
@@ -3,20 +3,20 @@
 
 import pytest
 
-from cryptography.bindings import _ALL_APIS
+from cryptography.bindings import _ALL_BACKENDS
 from cryptography.primitives.block import BlockCipher
 
 
 def generate_encrypt_test(param_loader, path, file_names, cipher_factory,
-                          mode_factory, only_if=lambda api: True,
+                          mode_factory, only_if=lambda backend: True,
                           skip_message=None):
     def test_encryption(self):
-        for api in _ALL_APIS:
+        for backend in _ALL_BACKENDS:
             for file_name in file_names:
                 for params in param_loader(os.path.join(path, file_name)):
                     yield (
                         encrypt_test,
-                        api,
+                        backend,
                         cipher_factory,
                         mode_factory,
                         params,
@@ -26,16 +26,16 @@
     return test_encryption
 
 
-def encrypt_test(api, cipher_factory, mode_factory, params, only_if,
+def encrypt_test(backend, cipher_factory, mode_factory, params, only_if,
                  skip_message):
-    if not only_if(api):
+    if not only_if(backend):
         pytest.skip(skip_message)
     plaintext = params.pop("plaintext")
     ciphertext = params.pop("ciphertext")
     cipher = BlockCipher(
         cipher_factory(**params),
         mode_factory(**params),
-        api
+        backend
     )
     encryptor = cipher.encryptor()
     actual_ciphertext = encryptor.update(binascii.unhexlify(plaintext))
@@ -50,12 +50,12 @@
 def generate_hash_test(param_loader, path, file_names, hash_cls,
                        only_if=None, skip_message=None):
     def test_hash(self):
-        for api in _ALL_APIS:
+        for backend in _ALL_BACKENDS:
             for file_name in file_names:
                 for params in param_loader(os.path.join(path, file_name)):
                     yield (
                         hash_test,
-                        api,
+                        backend,
                         hash_cls,
                         params,
                         only_if,
@@ -64,25 +64,25 @@
     return test_hash
 
 
-def hash_test(api, hash_cls, params, only_if, skip_message):
-    if only_if is not None and not only_if(api):
+def hash_test(backend, hash_cls, params, only_if, skip_message):
+    if only_if is not None and not only_if(backend):
         pytest.skip(skip_message)
     msg = params[0]
     md = params[1]
-    m = hash_cls(api=api)
+    m = hash_cls(backend=backend)
     m.update(binascii.unhexlify(msg))
     assert m.hexdigest() == md.replace(" ", "").lower()
-    digest = hash_cls(api=api, data=binascii.unhexlify(msg)).hexdigest()
-    assert digest == md.replace(" ", "").lower()
+    digst = hash_cls(backend=backend, data=binascii.unhexlify(msg)).hexdigest()
+    assert digst == md.replace(" ", "").lower()
 
 
 def generate_base_hash_test(hash_cls, digest_size, block_size,
                             only_if=None, skip_message=None):
     def test_base_hash(self):
-        for api in _ALL_APIS:
+        for backend in _ALL_BACKENDS:
             yield (
                 base_hash_test,
-                api,
+                backend,
                 hash_cls,
                 digest_size,
                 block_size,
@@ -92,11 +92,11 @@
     return test_base_hash
 
 
-def base_hash_test(api, hash_cls, digest_size, block_size, only_if,
+def base_hash_test(backend, hash_cls, digest_size, block_size, only_if,
                    skip_message):
-    if only_if is not None and not only_if(api):
+    if only_if is not None and not only_if(backend):
         pytest.skip(skip_message)
-    m = hash_cls(api=api)
+    m = hash_cls(backend=backend)
     assert m.digest_size == digest_size
     assert m.block_size == block_size
     m_copy = m.copy()
@@ -107,10 +107,10 @@
 def generate_long_string_hash_test(hash_factory, md, only_if=None,
                                    skip_message=None):
     def test_long_string_hash(self):
-        for api in _ALL_APIS:
+        for backend in _ALL_BACKENDS:
             yield(
                 long_string_hash_test,
-                api,
+                backend,
                 hash_factory,
                 md,
                 only_if,
@@ -119,9 +119,9 @@
     return test_long_string_hash
 
 
-def long_string_hash_test(api, hash_factory, md, only_if, skip_message):
-    if only_if is not None and not only_if(api):
+def long_string_hash_test(backend, hash_factory, md, only_if, skip_message):
+    if only_if is not None and not only_if(backend):
         pytest.skip(skip_message)
-    m = hash_factory(api=api)
+    m = hash_factory(backend=backend)
     m.update(b"a" * 1000000)
     assert m.hexdigest() == md.lower()