diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
new file mode 100644
index 0000000..fb79665
--- /dev/null
+++ b/.github/workflows/build.yaml
@@ -0,0 +1,39 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+    - name: Build package
+      run: python -m build
+    - name: Publish package
+      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+      with:
+        user: ${{ secrets.pypi_username }}
+        password: ${{ secrets.pypi_password }}
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..86db358
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,25 @@
+name: Lint and Test
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10"]
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install pytest pytest-asyncio
+        pip install -r requirements.txt
+    - name: Running tests
+      run: |
+        pytest agentbrowser/test.py
+        pytest agentbrowser/test_async.py
\ No newline at end of file
diff --git a/agentbrowser/__init__.py b/agentbrowser/__init__.py
index 53c748f..a547260 100644
--- a/agentbrowser/__init__.py
+++ b/agentbrowser/__init__.py
@@ -1,33 +1 @@
-"""
-agentbrowser
-
-A browser for your agent, built on Chrome and Pyppeteer.
-"""
-
-__version__ = "0.1.1"
-__author__ = "Moon (https://github.com/lalalune)"
-__credits__ = "https://github.com/lalalune/agentbrowser"
-
-from .browser import (
-    get_browser,
-    init_browser,
-    create_page,
-    close_page,
-    navigate_to,
-    get_body_text,
-    get_document_html,
-    get_body_html,
-    evaluate_javascript
-)
-
-__all__ = [
-    "get_browser",
-    "init_browser",
-    "create_page",
-    "navigate_to",
-    "close_page",
-    "get_document_html",
-    "get_body_text",
-    "get_body_html",
-    "evaluate_javascript",
-]
+from .browser import *
\ No newline at end of file
diff --git a/agentbrowser/browser.py b/agentbrowser/browser.py
index 0a54448..4522db1 100644
--- a/agentbrowser/browser.py
+++ b/agentbrowser/browser.py
@@ -7,59 +7,93 @@
 
 browser = None
 
-
 def get_browser():
-    check_browser_inited()
+    if browser is None:
+        init_browser()
+    return browser
+
+async def async_get_browser():
+    if browser is None:
+        await async_init_browser()
     return browser
 
 
 def init_browser(headless=True, executable_path=None):
-    if browser is not None:
-        asyncio.get_event_loop().run_until_complete(browser.close())
+    asyncio.get_event_loop().run_until_complete(
+        async_init_browser(headless, executable_path)
+    )
 
-    if executable_path is None:
-        executable_path = find_chrome()
 
-    async def init():
-        global browser
+def create_page(site=None):
+    return asyncio.get_event_loop().run_until_complete(async_create_page(site))
 
-        def handle_interrupt():
-            asyncio.ensure_future(browser.close())
-            asyncio.get_event_loop().stop()
 
-        browser = await launch(headless=headless, executablePath=executable_path)
-        signal.signal(signal.SIGINT, handle_interrupt)
+def close_page(page):
+    asyncio.get_event_loop().run_until_complete(async_close_page(page))
 
-    asyncio.get_event_loop().run_until_complete(init())
 
+def navigate_to(url, page):
+    return asyncio.get_event_loop().run_until_complete(async_navigate_to(url, page))
 
-def check_browser_inited():
-    if browser is None:
-        init_browser()
 
+def get_document_html(page):
+    return asyncio.get_event_loop().run_until_complete(async_get_document_html(page))
 
-def create_page(site=None):
-    check_browser_inited()
-    page = asyncio.get_event_loop().run_until_complete(browser.newPage())
+
+def get_body_text(page):
+    return asyncio.get_event_loop().run_until_complete(async_get_body_text(page))
+
+
+def get_body_text_raw(page):
+    return asyncio.get_event_loop().run_until_complete(async_get_body_text_raw(page))
+
+
+def get_body_html(page):
+    return asyncio.get_event_loop().run_until_complete(async_get_body_html(page))
+
+
+def evaluate_javascript(code, page):
+    return asyncio.get_event_loop().run_until_complete(
+        async_evaluate_javascript(code, page)
+    )
+
+
+# async version of init_browser
+async def async_init_browser(headless=True, executable_path=None):
+    global browser
+
+    if executable_path is None:
+        executable_path = find_chrome()
+
+    if browser is None:
+        browser = await launch(headless=headless, executablePath=executable_path, autoClose=False)
+    return browser
+
+# async version of create_page
+async def async_create_page(site=None):
+    global browser
+    new_browser = None
+    if browser is None:
+        new_browser = await async_init_browser()
+    else:
+        new_browser = browser
+    page = await new_browser.newPage()
     if site:
-        asyncio.get_event_loop().run_until_complete(
-            page.goto(site, {"waitUntil": ["domcontentloaded", "networkidle0"]})
-        )
+        await page.goto(site, {"waitUntil": ["domcontentloaded", "networkidle0"]})
     return page
 
 
-def close_page(page):
-    asyncio.get_event_loop().run_until_complete(page.close())
+# async version of close_page
+async def async_close_page(page):
+    await page.close()
 
 
-def navigate_to(url, page):
-    check_browser_inited()
+# async version of navigate_to
+async def async_navigate_to(url, page):
     if not page:
-        page = create_page(None)
+        page = await async_create_page(None)
     try:
-        asyncio.get_event_loop().run_until_complete(
-            page.goto(url, {"waitUntil": ["domcontentloaded", "networkidle0"]})
-        )
+        await page.goto(url, {"waitUntil": ["domcontentloaded", "networkidle0"]})
     except Exception as e:
         print("Error navigating to: " + url)
         print(e)
@@ -67,80 +101,28 @@ def navigate_to(url, page):
     return page
 
 
-def get_document_html(page):
-    return asyncio.get_event_loop().run_until_complete(page.content())
-
+# async version of get_document_html
+async def async_get_document_html(page):
+    return await page.content()
 
-def get_body_text(page):
-    # get the body, but remove some junk first
-    output = asyncio.get_event_loop().run_until_complete(
-        page.Jeval(
-            "body",
-            """
-        (element) => {
-            const element_blacklist = [
-                "sidebar",
-                "footer",
-                "account",
-                "login",
-                "signup",
-                "search",
-                "advertisement",
-                "masthead",
-                "popup",
-                "floater",
-                "modal",
-            ];
-            // first, filter out all the script tags, noscript tags, <footer>, <header>, etc
-            [...element.querySelectorAll('script, noscript, form, footer, header, img, svg, style')].forEach(element => element && element.remove())
-            // find any element which contains any class or id which includes the words in the blacklist
-            const blacklist = element_blacklist.join('|')
-            const regex = new RegExp(blacklist, 'i')
-            const blacklist_elements = [...element.querySelectorAll('*')].filter(element => element && ((element.id && element.id.match(regex)) || (element.className && element.className.match && element.className.match(regex))))
-            // remove all the blacklist elements
-            blacklist_elements.forEach(element => element && element.remove())
-            // replace any tags inside of the body with just their text content
-            const tags = [...element.querySelectorAll('*')]
-            tags.forEach(element => element && element.replaceWith(element.textContent))
-
-            // then, get the text content of the body element
-            let text = element.textContent
-            // finally, remove all the extra whitespace
-            text = text.replace(/\s+/g, ' ')
-            return text
-        }
-        """,
-        )
-    )
 
-    # remove any extra whitespace
-    output = re.sub(r"\s+", " ", output)
+async def async_get_body_text(page):
+    output = await page.querySelectorEval("body", "(element) => element.innerText")
+    return output.strip()
 
-    return output
+async def async_get_body_text_raw(page):
+    output = await page.querySelectorEval("body", "(element) => element.innerText")
+    return output.strip()
 
 
-def get_body_text_raw(page):
-    # get the raw body text, without any filtering
-    return asyncio.get_event_loop().run_until_complete(
-        page.Jeval(
-            "body",
-            """
-        (element) => {
-            return element.textContent
-        }
-        """,
-        )
-    )
+# async version of get_body_html
+async def async_get_body_html(page):
+    return await page.Jeval("body", "(element) => element.innerHTML")
 
 
-def get_body_html(page):
-    return asyncio.get_event_loop().run_until_complete(
-        page.Jeval("body", "(element) => element.innerHTML")
-    )
-
-
-def evaluate_javascript(code, page):
-    return asyncio.get_event_loop().run_until_complete(page.evaluate(code))
+# async version of evaluate_javascript
+async def async_evaluate_javascript(code, page):
+    return await page.evaluate(code)
 
 
 def find_chrome():
diff --git a/agentbrowser/browser_test.py b/agentbrowser/browser_test.py
deleted file mode 100644
index 51a6b61..0000000
--- a/agentbrowser/browser_test.py
+++ /dev/null
@@ -1,70 +0,0 @@
-from browser import (
-    get_browser,
-    init_browser,
-    navigate_to,
-    get_body_html,
-    get_body_text,
-    get_body_text_raw,
-    get_document_html,
-    create_page,
-    close_page,
-    evaluate_javascript,
-)
-
-
-def main():
-    # Initialize the browser
-    init_browser()
-
-    # Check if the browser has been initialized
-    assert get_browser() is not None, "Browser initialization failed."
-
-    test_page = create_page("https://www.google.com")
-    print("test_page")
-    print(test_page)
-
-    # navigate to google
-    navigate_to(
-        "https://www.lesswrong.com/posts/gEchYntjSXk9KXorK/uncontrollable-ai-as-an-existential-risk",
-        test_page,
-    )
-
-    body_html = get_body_html(test_page)
-    print("*** BODY HTML")
-    print(body_html)
-
-    # Get HTML
-    html = get_document_html(test_page)
-    print("*** HTML")
-    print(html)
-
-    # Get body
-    body = get_body_text(test_page)
-
-    print("*** BODY, test_page_2")
-    print(body)
-
-    body_text = get_body_text(test_page)
-
-    body_text_raw = get_body_text_raw(test_page)
-
-    print("*** BODY TEXT, test_page")
-    print(body_text)
-
-    print("*** BODY TEXT RAW, test_page")
-    print(body_text_raw)
-
-    evaluate_javascript(
-        """
-        var x = 1;
-        var y = 2;
-        var z = x + y;
-        console.log(z);
-        """,
-        test_page,
-    )
-
-    close_page(test_page)
-
-
-main()
diff --git a/agentbrowser/test.py b/agentbrowser/test.py
new file mode 100644
index 0000000..021c5c6
--- /dev/null
+++ b/agentbrowser/test.py
@@ -0,0 +1,104 @@
+import asyncio
+import pytest
+from agentbrowser import (
+    async_get_browser,
+    async_init_browser,
+    async_navigate_to,
+    async_get_body_html,
+    async_get_body_text,
+    async_get_document_html,
+    async_create_page,
+    async_close_page,
+    async_evaluate_javascript,
+    async_get_body_text_raw,
+    create_page,
+    evaluate_javascript,
+    get_body_html,
+    get_body_text,
+    get_document_html,
+    navigate_to,
+)
+from agentbrowser.browser import get_body_text_raw
+
+test_article = "https://test-page-to-crawl.vercel.app"
+
+
+@pytest.fixture(scope="function")
+async def browser_fixture(request):
+    # Initialize a new event loop for this test
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    # Initialize the browser
+    await async_init_browser()
+    assert await async_get_browser() is not None, "Browser initialization failed."
+
+    async def fin():
+        # cleanup after tests
+        if await async_get_browser() is not None:
+            await (await async_get_browser()).close()
+
+        loop.run_until_complete(
+            asyncio.sleep(0.250)
+        )  # gives tasks a bit of time to finish
+
+    request.addfinalizer(fin)
+
+    yield
+
+
+def test_navigation(browser_fixture):
+    test_page = create_page("https://www.google.com")
+
+    # navigate to google
+    navigate_to(
+        "https://www.yahoo.com",
+        test_page,
+    )
+
+    assert test_page.url != "https://www.google.com", "Navigation failed."
+    assert test_page is not None, "Page navigation failed."
+    print("test_navigation passed.")
+
+
+def test_body_html(browser_fixture):
+    test_page = create_page(test_article)
+    body_html = get_body_html(test_page)
+    assert body_html is not None, "Failed to get body html."
+    print("test_body_html passed.")
+
+
+def test_document_html(browser_fixture):
+    test_page = create_page(test_article)
+    html = get_document_html(test_page)
+    assert html is not None, "Failed to get document html."
+    print("test_document_html passed.")
+
+
+def test_body_text(browser_fixture):
+    test_page = create_page(test_article)
+    body = get_body_text(test_page)
+    assert body is not None, "Failed to get body text."
+    print("test_body_text passed.")
+
+
+def test_body_text_raw(browser_fixture):
+    test_page = create_page(test_article)
+    body_text_raw = get_body_text_raw(test_page)
+    assert body_text_raw is not None, "Failed to get raw body text."
+    print("test_body_text_raw passed.")
+
+
+def test_javascript_evaluation(browser_fixture):
+    test_page = create_page(test_article)
+    result = evaluate_javascript(
+        """
+        var x = 1;
+        var y = 2;
+        var z = x + y;
+        z;
+        """,
+        test_page,
+    )
+    assert result == 3, "Javascript evaluation failed."
+    print("test_javascript_evaluation passed.")
diff --git a/agentbrowser/test_async.py b/agentbrowser/test_async.py
new file mode 100644
index 0000000..0a3ec6f
--- /dev/null
+++ b/agentbrowser/test_async.py
@@ -0,0 +1,93 @@
+import asyncio
+import pytest
+from agentbrowser import (
+    async_get_browser,
+    async_init_browser,
+    async_navigate_to,
+    async_get_body_html,
+    async_get_body_text,
+    async_get_document_html,
+    async_create_page,
+    async_close_page,
+    async_evaluate_javascript,
+    async_get_body_text_raw,
+)
+from agentbrowser.browser import get_body_text_raw
+
+test_article = "https://test-page-to-crawl.vercel.app"
+
+
+@pytest.fixture(scope="function")
+async def browser_fixture(request):
+    # Initialize a new event loop for this test
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    # Initialize the browser
+    await async_init_browser()
+    assert await async_get_browser() is not None, "Browser initialization failed."
+
+    async def fin():
+        # cleanup after tests
+        if await async_get_browser() is not None:
+            await (await async_get_browser()).close()
+
+        loop.run_until_complete(
+            asyncio.sleep(0.250)
+        )  # gives tasks a bit of time to finish
+
+    request.addfinalizer(fin)
+
+    yield
+
+
+@pytest.mark.asyncio
+async def test_async_create_page(browser_fixture):
+    test_page = await async_create_page("https://www.google.com/")
+    assert test_page is not None, "Page navigation failed."
+    assert test_page.url == "https://www.google.com/", "Navigation failed."
+    print("test_create_page passed.")
+
+    await async_close_page(test_page)
+    assert test_page.isClosed(), "Page failed to close."
+    print("test_close_page passed.")
+
+    test_page = await async_create_page("https://www.google.com")
+
+    # navigate to google
+    await async_navigate_to(
+        "https://www.yahoo.com",
+        test_page,
+    )
+
+    assert test_page.url != "https://www.google.com", "Navigation failed."
+    assert test_page is not None, "Page navigation failed."
+    print("test_async_navigation passed.")
+
+    body_html = await async_get_body_html(test_page)
+    assert body_html is not None, "Failed to get body html."
+    print("test_async_body_html passed.")
+
+    html = await async_get_document_html(test_page)
+    assert html is not None, "Failed to get document html."
+    print("test_async_document_html passed.")
+
+    body = await async_get_body_text(test_page)
+    assert body is not None, "Failed to get body text."
+    print("test_async_body_text passed.")
+
+    body_text_raw = await async_get_body_text_raw(test_page)
+    assert body_text_raw is not None, "Failed to get raw body text."
+    print("test_async_body_text_raw passed.")
+
+    result = await async_evaluate_javascript(
+        """
+        var x = 1;
+        var y = 2;
+        var z = x + y;
+        z;
+        """,
+        test_page,
+    )
+    assert result == 3, "Javascript evaluation failed."
+    print("test_async_javascript_evaluation passed.")
\ No newline at end of file
diff --git a/publish.sh b/publish.sh
deleted file mode 100644
index ca372ee..0000000
--- a/publish.sh
+++ /dev/null
@@ -1,44 +0,0 @@
-set -e  # if any step fails, kill the entire script and warn the user something went wrong
-
-# get VERSION from args --version=
-VERSION=${1/--version=/}
-
-export TWINE_USERNAME=${2/--username=/}
-export TWINE_PASSWORD=${3/--password=/}
-
-# in setup.py, replace the line '\tversion=...' with '\tversion={VERSION}'
-sed -i.bak "s/version=.*/version='${VERSION}',/" setup.py
-
-# remove setup.py.bak
-rm "setup.py.bak"
-
-# Read agentbrowser/__init__.py, find the line that starts with __version__ and replace with '__version__ = "${VERSION}"'
-sed -i.bak "s/__version__.*/__version__ = \"${VERSION}\"/" agentbrowser/__init__.py
-rm agentbrowser/__init__.py.bak
-
-# Check if these dependencies are installed, and install them if they aren't
-pip install twine || echo "Failed to install twine"
-pip install wheel || echo "Failed to install wheel"
-
-# Make sure these work, and stop the script if they error
-# Run setup checks and build
-python setup.py check || { echo "Setup check failed"; exit 1; }
-python setup.py sdist || { echo "Source distribution build failed"; exit 1; }
-python setup.py bdist_wheel --universal || { echo "Wheel build failed"; exit 1; }
-
-# Make sure these work, and stop the script if they error
-# Upload to test repo
-twine upload dist/agentbrowser-${VERSION}.tar.gz --repository-url https://test.pypi.org/legacy/ || { echo "Upload to test repo failed"; exit 1; }
-pip install --index-url https://test.pypi.org/simple/ agentbrowser --user || { echo "Installation from test repo failed"; exit 1; }
-
-# Final upload
-twine upload dist/agentbrowser-${VERSION}.tar.gz || { echo "Final upload failed"; exit 1; }
-pip install agentbrowser --user || { echo "Installation of agentbrowser failed"; exit 1; }
-
-git add agentbrowser/__init__.py
-git add setup.py
-git commit -m "Updated to ${VERSION} and published"
-git push origin main
-
-# Let the user know that everything completed successfully
-echo "Script completed successfully"
diff --git a/run_tests.sh b/run_tests.sh
deleted file mode 100644
index cabd543..0000000
--- a/run_tests.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/bash
-
-python3 agentbrowser/memory_test.py
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 7e62568..811c7b5 100644
--- a/setup.py
+++ b/setup.py
@@ -12,7 +12,6 @@
 
 setup(
     name="agentbrowser",
-    version='0.1.1',
     description="A browser for your agent, built on Chrome and Pyppeteer.",
     long_description=long_description,  # added this line
     long_description_content_type="text/markdown",  # and this line